// index.js
const dishApi = require('../../api/dish');
const cartApi = require('../../api/cart');
const restaurantApi = require('../../api/restaurant');
const categoryApi = require('../../api/category');
const setmealApi = require('../../api/setmeal');
const orderApi = require('../../api/order');

Page({
  data: {
    // 餐厅信息
    restaurantInfo: {
      status: '加载中...',
      name: '毓秀餐厅',
      description: '为顾客打造专业的大众化美食外送餐饮',
      address: '北京市朝阳区新街大道一号楼8层',
      distance: '1.5km',
      deliveryFee: '6元',
      estimatedTime: '12min'
    },
    // 当前选中的分类索引
    currentCategory: 0,
    // 分类列表（包含菜品和套餐分类）
    categoryList: [],
    // 菜品/套餐列表
    dishList: [],
    // 购物车总数
    cartTotal: 0,
    // 购物车总金额
    cartAmount: 0,
    // 购物车列表
    cartList: [],
    // 是否显示购物车弹窗
    showCart: false,
    // 是否显示规格选择弹窗
    showSpec: false,
    // 当前选中的菜品（用于规格选择）
    currentDish: {},
    // 规格选项
    specOptions: {
      spicy: []
    },
    // 默认地址信息
    defaultAddress: null
  },

  onLoad() {
    // 检查登录状态
    this.checkLoginStatus().catch(() => {
      // 登录失败或用户取消登录的处理
      console.log('登录失败或用户取消登录');
    });
  },

  // 检查登录状态
  checkLoginStatus() {
    const token = wx.getStorageSync('token');
    if (!token) {
      // 如果未登录，显示登录提示
      return new Promise((resolve, reject) => {
        wx.showModal({
          title: '温馨提示',
          content: '亲，授权微信登录后才能点餐！',
          confirmText: '去授权',
          cancelText: '暂不授权',
          success: (res) => {
            if (res.confirm) {
              // 用户点击确定，开始登录流程
              this.login().then(resolve).catch(reject);
            } else {
              // 用户点击取消，显示提示
              wx.showToast({
                title: '需要授权才能点餐',
                icon: 'none',
                duration: 2000
              });
              reject(new Error('用户取消授权'));
            }
          }
        });
      });
    } else {
      // 已登录，加载数据
      this.loadInitialData();
      return Promise.resolve();
    }
  },

  // 微信登录
  login() {
    return new Promise((resolve, reject) => {
      // 先获取用户授权
      wx.getUserProfile({
        desc: '获取你的昵称、头像',
        success: (profileRes) => {
          // 获取用户授权成功后，进行登录
          console.log('用户授权信息', profileRes);
          wx.login({
            success: (res) => {
              if (res.code) {
                // 调用后端登录接口
                const userApi = require('../../api/user');
                userApi.login(res.code).then(loginRes => {
                  if (loginRes.code === 1) {
                    // 保存token和用户信息
                    wx.setStorageSync('token', loginRes.data.token);
                    wx.setStorageSync('userInfo', profileRes.userInfo);
                    // 显示登录成功提示
                    wx.showToast({
                      title: '登录成功',
                      icon: 'success',
                      duration: 1500
                    });
                    // 加载数据
                    this.loadInitialData();
                    // 登录成功
                    resolve();
                  } else {
                    wx.showToast({
                      title: '登录失败',
                      icon: 'none'
                    });
                    reject(new Error('登录失败'));
                  }
                }).catch(err => {
                  console.error('登录失败', err);
                  wx.showToast({
                    title: '登录失败',
                    icon: 'none'
                  });
                  reject(err);
                });
              } else {
                reject(new Error('获取登录码失败'));
              }
            },
            fail: (err) => {
              reject(err);
            }
          });
        },
        fail: () => {
          // 用户拒绝授权
          wx.showToast({
            title: '需要授权才能点餐',
            icon: 'none'
          });
          reject(new Error('用户拒绝授权'));
        }
      });
    });
  },

  // 加载初始数据
  loadInitialData() {
    // 加载餐厅信息
    this.loadRestaurantInfo();
    // 加载分类列表（包括菜品和套餐分类）
    this.loadAllCategories();
    // 加载购物车信息
    this.loadCartInfo();
    // 加载默认地址
    this.loadDefaultAddress();
  },
  
  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 检查登录状态
    const token = wx.getStorageSync('token');
    if (token) {
        // 已登录，执行正常逻辑
        // 刷新购物车信息
        this.loadCartInfo();
      
      // 检查是否需要显示购物车（从再来一单跳转过来）
      const app = getApp();
      if (app.globalData.showCartAfterRedirect) {
        // 清除标记
        app.globalData.showCartAfterRedirect = false;
        // 显示购物车
        this.setData({
          showCart: true
        });
      }
    }
  },

  // 加载餐厅信息
  loadRestaurantInfo() {
    
    // 获取餐厅营业状态
    restaurantApi.getBusinessStatus().then(res => {
      if (res.code === 1) {
        // 更新营业状态 0表示休息中 1表示营业中
        const statusText = res.data === 1 ? '营业中' : '休息中';
        this.setData({
          'restaurantInfo.status': statusText
        });
      }
    }).catch(err => {
      console.error('获取营业状态失败', err);
    });
  },

  // 加载所有分类（菜品和套餐）
  loadAllCategories() {
    // 获取所有分类列表
    categoryApi.getCategoryList().then(res => {
      if (res.code === 1 && res.data) {
        // 按type字段排序，确保菜品分类在前，套餐分类在后
        const allCategories = res.data.sort((a, b) => a.type - b.type);
      
      if (allCategories.length > 0) {
        this.setData({
          categoryList: allCategories
        });
        // 加载默认分类的内容
        const defaultCategory = allCategories[0];
        if (defaultCategory.type === 2) {
          this.loadSetmealList(defaultCategory.id);
        } else {
          this.loadDishList(defaultCategory.id);
        }
      } else {
        wx.showToast({
          title: '暂无分类数据',
          icon: 'none'
        });
      }
     } 
    }).catch(err => {
      console.error('获取分类列表失败', err);
      wx.showToast({
        title: '获取分类失败',
        icon: 'none'
      });
    });
  },

  // 加载分类下的菜品列表
  loadDishList(categoryId) {
    wx.showLoading({
      title: '加载中...'
    });
    
    // 根据分类ID获取菜品列表
    dishApi.getDishList(categoryId).then(res => {
      wx.hideLoading();
      if (res.code === 1 && res.data) {
        // 处理返回的菜品数据，添加count字段用于购物车计数
        const dishList = res.data.map(dish => ({
          ...dish,
          count: 0, // 添加数量字段
          hasSpecs: dish.flavors && dish.flavors.length > 0 // 根据口味数据判断是否有规格
        }));
        
        // 更新购物车中的数量
        const { cartList } = this.data;
        if (cartList && cartList.length > 0) {
          dishList.forEach(dish => {
            // 查找购物车中对应的菜品（可能有多个，因为不同口味算不同商品）
            const cartItems = cartList.filter(item => item.dishId === dish.id);
            if (cartItems && cartItems.length > 0) {
              // 计算该菜品在购物车中的总数量
              dish.count = cartItems.reduce((total, item) => total + item.count, 0);
            }
          });
        }
        
        this.setData({
          dishList
        });
      } else {
        // 如果没有获取到菜品或发生错误，使用模拟数据
        // 这里保留原有的模拟数据，实际项目中可以显示空状态
        wx.showToast({
          title: '暂无菜品数据',
          icon: 'none'
        });
      }
    }).catch(err => {
      wx.hideLoading();
      console.error('获取菜品列表失败', err);
      wx.showToast({
        title: '获取菜品失败',
        icon: 'none'
      });
    });
  },

  // 加载套餐列表
  loadSetmealList(categoryId) {
    wx.showLoading({
      title: '加载中...'
    });
    
    // 根据分类ID获取套餐列表
    setmealApi.getSetmealList(categoryId).then(res => {
      wx.hideLoading();
      if (res.code === 1 && res.data) {
        // 处理返回的套餐数据，添加count字段用于购物车计数
        const setmealList = res.data.map(setmeal => ({
          ...setmeal,
          count: 0, // 添加数量字段
          isSetmeal: true // 标记为套餐
        }));
        
        // 更新购物车中的数量
        const { cartList } = this.data;
        if (cartList && cartList.length > 0) {
          setmealList.forEach(setmeal => {
            // 查找购物车中对应的套餐
            const cartItems = cartList.filter(item => item.setmealId === setmeal.id);
            if (cartItems && cartItems.length > 0) {
              // 计算该套餐在购物车中的总数量
              setmeal.count = cartItems.reduce((total, item) => total + item.count, 0);
            }
          });
        }
        
        this.setData({
          dishList: setmealList // 使用dishList统一显示菜品和套餐
        });
      } else {
        // 如果没有获取到套餐或发生错误，显示提示
        wx.showToast({
          title: '暂无套餐数据',
          icon: 'none'
        });
        this.setData({
          dishList: [] // 清空列表
        });
      }
    }).catch(err => {
      wx.hideLoading();
      console.error('获取套餐列表失败', err);
      wx.showToast({
        title: '获取套餐失败',
        icon: 'none'
      });
      this.setData({
        dishList: [] // 清空列表
      });
    });
  },
  
  // 加载购物车信息 - 使用API实现
  loadCartInfo() {
    // 调用购物车API获取购物车数据
    const cartApi = require('../../api/cart');
    cartApi.getCartList().then(res => {
      if (res.code === 1) {
        // 处理返回的购物车数据
        const cartList = res.data.map(item => {
          // 处理口味信息，将dishFlavor转换为用户友好的显示格式
          let flavorName = '';
          if (item.dishFlavor && item.dishFlavor.trim() !== '') {
            // 尝试解析口味信息
            try {
              // 检查是否是JSON格式
              if (item.dishFlavor.startsWith('[') && item.dishFlavor.endsWith(']')) {
                const flavors = JSON.parse(item.dishFlavor);
                flavorName = flavors.join(',');
              } else if (item.dishFlavor.includes(',')) {
                // 逗号分隔的格式
                flavorName = item.dishFlavor;
              } else {
                // 单个值
                flavorName = item.dishFlavor;
              }
            } catch (error) {
              console.error('解析口味信息失败:', error);
              flavorName = item.dishFlavor; // 解析失败时直接使用原始值
            }
          }
          
          return {
            id: item.id,
            dishId: item.dishId || null,
            setmealId: item.setmealId || null,
            name: item.name,
            image: item.image,
            price: item.amount,
            count: item.number,  // 使用后端返回的number作为count
            dishFlavor: item.dishFlavor || '',
            flavorName: flavorName, // 添加用户友好的口味显示
            isSetmeal: item.setmealId !== null // 根据setmealId判断是否为套餐
          };
        });
        
        // 计算总数和总金额
        let total = 0;
        let amount = 0;
        cartList.forEach(item => {
          total += item.count;
          amount += item.price * item.count;
        });
        
        // 更新菜品和套餐列表中的数量
        const { dishList } = this.data;
        const updatedDishList = dishList.map(dish => {
          // 根据是否为套餐查找对应的购物车项（可能有多个，因为不同口味算不同商品）
          const cartItems = cartList.filter(item => {
            if (dish.isSetmeal) {
              return item.setmealId === dish.id;
            } else {
              return item.dishId === dish.id;
            }
          });
          
          // 计算该菜品/套餐在购物车中的总数量
          const totalCount = cartItems.reduce((total, item) => total + item.count, 0);
          
          return {
            ...dish,
            count: totalCount
          };
        });
        
        this.setData({
          cartList,
          cartTotal: total,
          cartAmount: amount,
          dishList: updatedDishList
        });
      } else {
        console.error('获取购物车失败', res.msg);
      }
    }).catch(err => {
      console.error('获取购物车失败', err);
    });
  },

  // 切换分类
  switchCategory(e) {
    const index = e.currentTarget.dataset.index;
    this.setData({
      currentCategory: index
    });
    
    // 加载对应分类的菜品
    const category = this.data.categoryList[index];
    const categoryId = category.id;
    
    // 判断分类类型，加载对应的数据
    if (category.type === 2) {
      // 套餐分类，加载套餐列表
      this.loadSetmealList(categoryId);
    } else {
      // 默认为菜品分类，加载菜品列表
      this.loadDishList(categoryId);
    }
  },

  // 查看菜品或套餐详情
  viewDishDetail(e) {
    const id = e.currentTarget.dataset.id;
    const isSetmeal = e.currentTarget.dataset.issetmeal;
    
    if (isSetmeal) {
      // 查看套餐详情
      wx.navigateTo({
        url: `/pages/setmealDetail/setmealDetail?id=${id}`
      });
    } else {
      // 查看菜品详情
      wx.navigateTo({
        url: `/pages/dishDetail/dishDetail?id=${id}`
      });
    }
  },

  // 选择规格 - 更安全的版本
  selectSpec(e) {
    const id = e.currentTarget.dataset.id;
    const dish = this.data.dishList.find(item => item.id === id);
    
    if (!dish || !dish.flavors) return;
    
    console.log('菜品口味数据:', dish.flavors); // 调试用，查看实际数据格式
    
    // 处理口味数据
    const specOptions = {
      spicy: []
    };
    
    dish.flavors.forEach((flavor, flavorIndex) => {
      let options = [];
      
      console.log(`口味 ${flavorIndex}:`, flavor); // 调试用
      
      try {
        if (!flavor.value) {
          console.warn('口味值为空:', flavor);
          return;
        }
        
        let valueStr = String(flavor.value).trim();
        
        // 多种格式的处理
        if (valueStr.startsWith('[') && valueStr.endsWith(']')) {
          // JSON 数组格式: ["不辣", "微辣", "中辣"]
          options = JSON.parse(valueStr);
        } else if (valueStr.includes(',')) {
          // 逗号分隔格式: "不辣,微辣,中辣"
          options = valueStr.split(',').map(item => item.trim()).filter(item => item);
        } else if (valueStr.includes('|')) {
          // 竖线分隔格式: "不辣|微辣|中辣"
          options = valueStr.split('|').map(item => item.trim()).filter(item => item);
        } else {
          // 单个值
          options = [valueStr];
        }
        
      } catch (error) {
        console.error('解析口味数据失败:', error, flavor);
        // 最后的备用方案
        let valueStr = String(flavor.value);
        if (valueStr.includes(',')) {
          options = valueStr.split(',').map(item => item.trim()).filter(item => item);
        } else {
          options = [valueStr];
        }
      }
      
      // 确保 options 是数组且不为空
      if (!Array.isArray(options) || options.length === 0) {
        console.warn('无法解析口味选项:', flavor);
        options = [String(flavor.value || '默认')];
      }
      
      // 添加到规格选项中
      options.forEach(option => {
        if (option && option.trim()) {
          specOptions.spicy.push({
            label: flavor.name || '口味', // 口味类型名称
            value: option.trim(),         // 具体选项
            selected: false
          });
        }
      });
    });
    
    if (specOptions.spicy.length === 0) {
      wx.showToast({
        title: '暂无可选规格',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      currentDish: dish,
      specOptions,
      showSpec: true
    });
  },

  // 选择规格选项 - 支持多选
  selectSpicyOption(e) {
    const index = e.currentTarget.dataset.index;
    const { specOptions } = this.data;
    
    // 切换选中状态（支持多选）
    const updatedSpicy = specOptions.spicy.map((item, idx) => {
      if (idx === index) {
        return {
          ...item,
          selected: !item.selected // 切换选中状态
        };
      }
      return item;
    });
    
    this.setData({
      'specOptions.spicy': updatedSpicy
    });
  },

  // 关闭规格选择弹窗
  closeSpec() {
    this.setData({
      showSpec: false,
      currentDish: {},
      specOptions: {
        spicy: []
      }
    });
  },

  // 添加规格菜品到购物车 - 使用API实现
  addSpecDishToCart() {
    const { currentDish, specOptions } = this.data;
    
    // 获取所有选中的规格
    const selectedFlavors = specOptions.spicy.filter(item => item.selected);
    
    if (selectedFlavors.length === 0) {
      wx.showToast({
        title: '请选择规格',
        icon: 'none'
      });
      return;
    }
    
    // 生成规格描述字符串
    const flavorDesc = selectedFlavors.map(item => `${item.value}`).join(',');
    
    // 准备添加购物车的参数
    const params = {
      dishId: currentDish.id,
      dishFlavor: flavorDesc,
      setmealId: null // 非套餐，设置为0
    };
    
    // 调用购物车API
    const cartApi = require('../../api/cart');
    cartApi.addToCart(params).then(res => {
      if (res.code === 1) {
        // 关闭规格选择弹窗
        this.closeSpec();
        
        // 刷新购物车信息
        this.loadCartInfo();
        
        wx.showToast({
          title: '添加成功',
          icon: 'success'
        });
      } else {
        wx.showToast({
          title: res.msg || '添加失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('添加购物车失败', err);
      wx.showToast({
        title: '添加失败，请重试',
        icon: 'none'
      });
    });
  },

  // 增加商品数量 - 使用API实现
  increaseQuantity(e) {
    const id = e.currentTarget.dataset.id;
    const isSetmeal = e.currentTarget.dataset.issetmeal;
    const flavorKey = e.currentTarget.dataset.flavorKey || '';
    const { dishList, cartList } = this.data;
    const item = dishList.find(item => item.id === id);
    
    if (!item) return;
    
    // 如果是带有口味的菜品，需要找到对应的购物车项或者提示用户选择规格
    if (!isSetmeal && item.hasSpecs && !flavorKey) {
      // 如果是有规格的菜品但没有指定口味，提示用户选择规格
      this.selectSpec({
        currentTarget: {
          dataset: {
            id: id
          }
        }
      });
      return;
    } else if (!isSetmeal && flavorKey) {
      // 如果指定了口味，使用该口味添加到购物车
      const params = {
        dishId: id,
        setmealId: null,
        dishFlavor: flavorKey
      };
      
      // 调用购物车API
      const cartApi = require('../../api/cart');
      cartApi.addToCart(params).then(res => {
        if (res.code === 1) {
          // 刷新购物车信息
          this.loadCartInfo();
          
          wx.showToast({
            title: '添加成功',
            icon: 'success'
          });
        } else {
          wx.showToast({
            title: res.msg || '添加失败',
            icon: 'none'
          });
        }
      }).catch(err => {
        console.error('添加购物车失败', err);
        wx.showToast({
          title: '添加失败，请重试',
          icon: 'none'
        });
      });
      return;
    }
    
    // 对于没有口味的菜品或套餐，使用原来的逻辑
    const params = {
      dishId: isSetmeal ? null : id,
      setmealId: isSetmeal ? id : null,
      dishFlavor: '' // 无规格
    };
    
    // 调用购物车API
    const cartApi = require('../../api/cart');
    cartApi.addToCart(params).then(res => {
      if (res.code === 1) {
        // 刷新购物车信息
        this.loadCartInfo();
        
        wx.showToast({
          title: '添加成功',
          icon: 'success'
        });
      } else {
        wx.showToast({
          title: res.msg || '添加失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('添加购物车失败', err);
      wx.showToast({
        title: '添加失败，请重试',
        icon: 'none'
      });
    });
  },
  
  // 减少商品数量 - 使用API实现
  decreaseQuantity(e) {
    const id = e.currentTarget.dataset.id;
    const isSetmeal = e.currentTarget.dataset.issetmeal;
    const flavorKey = e.currentTarget.dataset.flavorKey || '';
    
    // 如果是带有口味的菜品，需要找到对应的购物车项
    if (!isSetmeal && flavorKey) {
      // 查找购物车中对应的菜品和口味
      const { cartList } = this.data;
      const cartItem = cartList.find(item => 
        item.dishId === id && item.dishFlavor === flavorKey
      );
      
      if (cartItem) {
        // 使用购物车项中的口味信息
        const params = {
          dishId: id,
          setmealId: null,
          dishFlavor: cartItem.dishFlavor
        };
        
        // 调用购物车API
        const cartApi = require('../../api/cart');
        cartApi.removeFromCart(params).then(res => {
          if (res.code === 1) {
            // 刷新购物车信息
            this.loadCartInfo();
          } else {
            wx.showToast({
              title: res.msg || '操作失败',
              icon: 'none'
            });
          }
        }).catch(err => {
          console.error('减少购物车商品失败', err);
          wx.showToast({
            title: '操作失败，请重试',
            icon: 'none'
          });
        });
        return;
      }
    }
    
    // 对于没有口味的菜品或套餐，使用原来的逻辑
    const params = {
      dishId: isSetmeal ? null : id,
      setmealId: isSetmeal ? id : null,
      dishFlavor: '' // 无规格
    };
    
    // 调用购物车API
    const cartApi = require('../../api/cart');
    cartApi.removeFromCart(params).then(res => {
      if (res.code === 1) {
        // 刷新购物车信息
        this.loadCartInfo();
      } else {
        wx.showToast({
          title: res.msg || '操作失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('减少购物车商品失败', err);
      wx.showToast({
        title: '操作失败，请重试',
        icon: 'none'
      });
    });
  },

  // 增加购物车中商品数量 - 使用API实现
  increaseCartItem(e) {
    const id = e.currentTarget.dataset.id;
    const dishId = e.currentTarget.dataset.dishId || null;
    const setmealId = e.currentTarget.dataset.setmealId || null;
    const dishFlavor = e.currentTarget.dataset.dishFlavor || '';
    
    // 准备添加购物车的参数
    const params = {
      dishId: dishId,
      setmealId: setmealId,
      dishFlavor: dishFlavor
    };
    
    // 调用购物车API
    const cartApi = require('../../api/cart');
    cartApi.addToCart(params).then(res => {
      if (res.code === 1) {
        // 刷新购物车信息
        this.loadCartInfo();
      } else {
        wx.showToast({
          title: res.msg || '操作失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('增加购物车商品失败', err);
      wx.showToast({
        title: '操作失败，请重试',
        icon: 'none'
      });
    });
  },

  // 减少购物车中商品数量 - 使用API实现
  decreaseCartItem(e) {
    const id = e.currentTarget.dataset.id;
    const dishId = e.currentTarget.dataset.dishId || null;
    const setmealId = e.currentTarget.dataset.setmealId || null;
    const dishFlavor = e.currentTarget.dataset.dishFlavor || '';
    
    // 准备删除购物车的参数
    const params = {
      dishId: dishId,
      setmealId: setmealId,
      dishFlavor: dishFlavor
    };
    
    // 调用购物车API
    const cartApi = require('../../api/cart');
    cartApi.removeFromCart(params).then(res => {
      if (res.code === 1) {
        // 刷新购物车信息
        this.loadCartInfo();
      } else {
        wx.showToast({
          title: res.msg || '操作失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('减少购物车商品失败', err);
      wx.showToast({
        title: '操作失败，请重试',
        icon: 'none'
      });
    });
  },
  
  // 清空购物车 - 使用API实现
  clearCart() {
    wx.showModal({
      title: '提示',
      content: '确定要清空购物车吗？',
      success: (res) => {
        if (res.confirm) {
          // 调用购物车API
          const cartApi = require('../../api/cart');
          cartApi.clearCart().then(res => {
            if (res.code === 1) {
              // 刷新购物车信息
              this.loadCartInfo();
              
              // 关闭购物车弹窗
              this.setData({
                showCart: false
              });
              
              wx.showToast({
                title: '购物车已清空',
                icon: 'success'
              });
            } else {
              wx.showToast({
                title: res.msg || '清空购物车失败',
                icon: 'none'
              });
            }
          }).catch(err => {
            console.error('清空购物车失败', err);
            wx.showToast({
              title: '清空购物车失败，请重试',
              icon: 'none'
            });
          });
        }
      }
    });
  },

  // 切换购物车显示状态
  toggleCart() {
    if (this.data.cartTotal <= 0 && !this.data.showCart) {
      wx.showToast({
        title: '购物车为空',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      showCart: !this.data.showCart
    });
  },

  // 加载默认地址
  loadDefaultAddress() {
    const addressApi = require('../../api/address');
    addressApi.getDefaultAddress().then(res => {
      if (res.code === 1 && res.data) {
        this.setData({
          defaultAddress: res.data
        });
      }
    }).catch(err => {
      console.error('获取默认地址失败', err);
    });
  },

  // 去结算
  checkout() {
    if (this.data.cartTotal <= 0) {
      wx.showToast({
        title: '请先选择商品',
        icon: 'none'
      });
      return;
    }

    // 检查是否有默认地址
    if (!this.data.defaultAddress) {
      wx.showModal({
        title: '提示',
        content: '请先设置默认收货地址',
        confirmText: '去设置',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/address/address'
            });
          }
        }
      });
      return;
    }
    
    // 获取购物车数据
    const { cartList, cartAmount, defaultAddress } = this.data;
    
    // 显示加载中
    wx.showLoading({
      title: '正在创建订单',
      mask: true
    });
    
    // 准备订单数据
    const orderData = {
      addressBookId: defaultAddress.id,
      amount: cartAmount + 5, // 总金额 = 商品金额 + 配送费 - 优惠金额
      deliveryStatus: 1, // 1立即送出 0选择具体时间
      estimatedDeliveryTime: '', // 预计送达时间，立即送出时为空
      packAmount: 0, // 打包费
      payMethod: 1, // 默认微信支付，在支付页面可以修改
      remark: '', // 备注
      tablewareNumber: 0, // 餐具数量
      tablewareStatus: 1, // 1按餐量提供 0选择具体数量
      shoppingCart: cartList.map(item => ({
        dishId: item.dishId || null,
        setmealId: item.setmealId || null,
        dishFlavor: item.dishFlavor || '',
        number: item.count
      }))
    };
    
    // 调用API创建订单
    orderApi.submitOrder(orderData).then(res => {
      wx.hideLoading();
      
      if (res.code === 1 && res.data) {
        // 订单创建成功
        
        // 关闭购物车弹窗
        this.setData({
          showCart: false
        });
        
        // 跳转到支付页面，传递订单ID
        wx.navigateTo({
          url: `/pages/payment/payment?id=${res.data.id}`
        });
      } else {
        wx.showToast({
          title: res.msg || '创建订单失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('创建订单失败:', err);
      wx.hideLoading();
      wx.showToast({
        title: '创建订单失败，请重试',
        icon: 'none'
      });
    });
  },

  // 跳转到个人中心
  goToUserCenter() {
    wx.navigateTo({
      url: '/pages/user/user'
    });
  }
})